/**
 * 1、类成员的可见性
 *      用来控制class的方法和属性，让class的外部是不是可以使用
 * 2、public:公有的，默认
 *    protected:受保护的；
 *              仅对其声明所在的自己的类和子类中（非实例对象）可见
 *              在子类的方法内部可以通过this来访问父类中受保护的成员，但是，对实例不可见
 *    private:私有的
 */
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
//一、public
//父类
var Animals = /** @class */ (function () {
    function Animals() {
    }
    Animals.prototype.move = function () {
        console.log("移动");
    };
    return Animals;
}());
//子类
var Dog = /** @class */ (function (_super) {
    __extends(Dog, _super);
    function Dog() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Dog.prototype.brak = function () {
        console.log("叫汪汪");
    };
    return Dog;
}(Animals));
var b = new Dog();
//让move方法只能再父类内部使用
b.move(); //子类可以访问到
//二、protected
var Animals2 = /** @class */ (function () {
    function Animals2() {
    }
    Animals2.prototype.move = function () {
        console.log("protected移动");
    };
    Animals2.prototype.huoguo2 = function () {
        //在当前自己的类中调用受保护的move方法
        this.move();
    };
    return Animals2;
}());
var Dog2 = /** @class */ (function (_super) {
    __extends(Dog2, _super);
    function Dog2() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Dog2.prototype.back1 = function () {
        console.log("dog2的汪汪");
        this.move();
    };
    return Dog2;
}(Animals2));
var d = new Dog2();
d.back1(); // dog2的汪汪,protected移动  这时是d在调用back1这个函数
// d.move //这个用法就会报错，属性“move”受保护，只能在类“Animals2”及其子类中访问。
//三、private私有的
var Animals3 = /** @class */ (function () {
    function Animals3() {
    }
    Animals3.prototype.privateFun = function () {
        console.log("私有的方法");
    };
    Animals3.prototype.Fun = function () {
        console.log("公有的方法");
    };
    return Animals3;
}());
var Dog3 = /** @class */ (function (_super) {
    __extends(Dog3, _super);
    function Dog3() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Dog3.prototype.sonFun = function () {
        console.log("子类的方法");
        this.Fun();
        // this.privateFun //这时就会报错，属性“privateFun”为私有属性，只能在类“Animals3”中访问。
    };
    return Dog3;
}(Animals3));
var a = new Dog3();
a.sonFun();
